import 'dart:io';
import 'package:flutter/services.dart';
import 'package:flutter/foundation.dart';
import 'package:path_provider/path_provider.dart';

class ScriptRunnerService {
  // 脚本进程
  Process? _process;
  // 输出更新回调
  final Function(String) onOutputUpdated;
  // 运行状态变化回调
  final Function(bool) onRunningStateChanged;

  ScriptRunnerService({
    required this.onOutputUpdated,
    required this.onRunningStateChanged,
  });

  // 内部日志方法，用于替代print调用
  void _log(String message) {
    // 仅在调试模式下输出到调试控制台
    assert(() {
      debugPrint(message);
      return true;
    }());
    // 同时将消息传递给UI显示回调
    onOutputUpdated("\n[调试] $message\n");
  }

  // Get desktop path
  Future<String> getDesktopPath() async {
    try {
      if (Platform.isMacOS) {
        // 步骤1: 在macOS上，直接使用硬编码路径方式获取桌面
        // 这种方式可以绕过沙盒环境的路径限制，确保获取真实桌面路径
        final username = Platform.environment['USER'] ?? 'hm';
        // 构造标准的macOS桌面路径格式: /Users/用户名/Desktop
        final desktopPath = '/Users/$username/Desktop';
        final desktopDir = Directory(desktopPath);

        // 步骤2: 验证构造的路径是否存在
        if (await desktopDir.exists()) {
          _log("使用直接桌面路径: $desktopPath");
          return desktopPath;
        }

        // 如果直接路径失败，记录日志（这种情况极少发生）
        _log("直接桌面路径访问失败，尝试备用方法");
      } else if (Platform.isWindows) {
        // 步骤3: Windows系统桌面路径处理
        // 从环境变量获取用户配置文件路径
        final userProfile = Platform.environment['USERPROFILE'];
        if (userProfile != null && userProfile.isNotEmpty) {
          // 构造Windows标准桌面路径: C:\Users\用户名\Desktop
          final desktopDir = Directory("$userProfile\\Desktop");
          if (await desktopDir.exists()) {
            return desktopDir.path;
          }
        }
      } else if (Platform.isLinux) {
        // 步骤4: Linux系统桌面路径处理
        // 从环境变量获取用户主目录
        final home = Platform.environment['HOME'];
        if (home != null && home.isNotEmpty) {
          // 构造Linux标准桌面路径: /home/用户名/Desktop
          final desktopDir = Directory("$home/Desktop");
          if (await desktopDir.exists()) {
            return desktopDir.path;
          }
        }
      }

      // 步骤5: 备用方法 - 使用whoami命令获取当前用户名
      // 这是一种更可靠的获取当前用户名的方式，特别是在环境变量不可用时
      try {
        final result = await Process.run('whoami', []);
        if (result.exitCode == 0) {
          final username = result.stdout.toString().trim();
          if (username.isNotEmpty) {
            // 根据获取到的用户名重新构造桌面路径
            final hardcodedPath = "/Users/$username/Desktop";
            final dir = Directory(hardcodedPath);
            if (await dir.exists()) {
              _log("通过whoami命令找到桌面路径: $hardcodedPath");
              return hardcodedPath;
            }
          }
        }
      } catch (e) {
        _log("使用whoami命令出错: $e");
      }

      // 步骤6: 所有方法都失败时的最终回退方案
      // 如果无法确定桌面路径，使用系统临时目录作为备用
      _log("无法确定桌面路径，使用临时目录代替");
      return Directory.systemTemp.path;
    } catch (e) {
      // 步骤7: 异常处理 - 捕获并记录任何未预期的错误
      _log("获取桌面路径时发生错误: $e");
      return Directory.systemTemp.path;
    }
  }

  // Extract script from assets to temp directory
  Future<File> extractScriptFromAssets() async {
    // 步骤1: 获取临时目录 - 为Python脚本创建一个工作目录
    final tempDir = await getTemporaryDirectory();
    final scriptDir = Directory('${tempDir.path}/flutter_scripts');

    // 步骤2: 确保脚本目录存在 - 如果不存在则创建
    if (!scriptDir.existsSync()) {
      scriptDir.createSync(recursive: true);
    }

    // 步骤3: 定义主脚本文件路径 - 将脚本保存到临时目录
    final scriptFile = File('${scriptDir.path}/create_project.py');

    try {
      // 步骤4: 从assets加载主脚本内容
      // 这里加载的是修改过的脚本，它包含了应用特定的自定义功能
      final scriptContent = await rootBundle
          .loadString('assets/scripts/create_project_modified.py');

      // 步骤5: 将脚本内容写入临时文件
      await scriptFile.writeAsString(scriptContent);

      // 步骤6: 设置脚本执行权限（尝试多种方法确保权限设置成功）
      onOutputUpdated("\n设置脚本执行权限...\n");

      try {
        // 使用chmod命令添加执行权限
        await Process.run('chmod', ['+x', scriptFile.path]);
      } catch (e) {
        onOutputUpdated("\n使用chmod设置脚本权限失败: $e\n");
      }

      // 步骤7: 尝试使用sudo设置权限（如果可用）
      // 在某些系统上可能需要管理员权限
      try {
        await Process.run('sudo', ['chmod', '+x', scriptFile.path]);
        onOutputUpdated("\n使用sudo设置脚本权限成功\n");
      } catch (e) {
        // sudo可能不可用，因此忽略错误
      }

      // 步骤8: 提取依赖模块文件
      // 主脚本依赖于这些模块，需要一起提取
      final dependencyFiles = [
        'lib_copier.py',
        'user_interaction.py',
        'utils.py',
        'flutter_project_creator.py',
      ];

      onOutputUpdated("\n提取依赖模块文件...");

      // 步骤9: 循环提取每个依赖模块
      for (final fileName in dependencyFiles) {
        try {
          // 从assets加载模块内容
          final moduleContent =
              await rootBundle.loadString('assets/scripts/$fileName');
          final moduleFile = File('${scriptDir.path}/$fileName');
          // 写入临时文件
          await moduleFile.writeAsString(moduleContent);

          // 也为模块文件设置执行权限
          try {
            await Process.run('chmod', ['+x', moduleFile.path]);
          } catch (e) {
            // 忽略模块的权限错误
          }

          onOutputUpdated("\n已提取模块: $fileName");
        } catch (e) {
          onOutputUpdated("\n提取模块 $fileName 时出错: $e");
          // 继续尝试提取其他模块，不要立即失败
        }
      }

      // 步骤10: 设置脚本目录权限
      // 确保整个目录及其内容都有适当的权限
      try {
        await Process.run('chmod', ['-R', '755', scriptDir.path]);
        onOutputUpdated("\n设置脚本目录权限成功\n");
      } catch (e) {
        onOutputUpdated("\n设置脚本目录权限失败: $e\n");
      }

      return scriptFile;
    } catch (e) {
      onOutputUpdated("\n提取脚本时出错: $e");
      rethrow;
    }
  }

  // Create parameters file
  Future<File> createParamsFile({
    required String projectType,
    required String templateType,
    required String projectName,
    required String packageName,
    required String displayName,
    required String outputPath,
    required String ideChoice,
    required String flutterSdkPath,
  }) async {
    // 步骤1: 确定参数文件位置 - 使用系统临时目录
    final tempDir = Directory.systemTemp;
    final file = File('${tempDir.path}/flutter_script_params.txt');

    // 步骤2: 获取Flutter路径 - 可能是用户指定的或系统默认的
    String flutterPath = await getFlutterPath(flutterSdkPath);

    // 步骤3: 检查并修复Flutter权限（如果使用特定路径）
    bool isFlutterValid = false;
    if (flutterPath != 'flutter') {
      // 如果是特定路径，尝试修复权限并验证
      isFlutterValid = await fixFlutterPermissions(flutterPath);
    } else {
      // 如果是默认'flutter'命令，尝试验证它是否可用
      try {
        // 使用which命令查找系统flutter位置
        final whichResult = await Process.run('which', ['flutter']);
        if (whichResult.exitCode == 0 &&
            whichResult.stdout.toString().trim().isNotEmpty) {
          final systemFlutterPath = whichResult.stdout.toString().trim();
          _log("在系统中找到Flutter: $systemFlutterPath");

          // 更新flutter路径为实际的系统路径
          flutterPath = systemFlutterPath;

          // 尝试修复权限并验证
          isFlutterValid = await fixFlutterPermissions(systemFlutterPath);
        } else {
          // 尝试直接运行flutter命令验证
          try {
            final versionResult = await Process.run('flutter', ['--version']);
            isFlutterValid = versionResult.exitCode == 0;
          } catch (e) {
            _log("验证系统Flutter时出错: $e");
            isFlutterValid = false;
          }
        }
      } catch (e) {
        _log("定位系统Flutter时出错: $e");
        isFlutterValid = false;
      }
    }

    // 步骤4: 如果Flutter路径无效，尝试查找其他可能的路径
    if (!isFlutterValid) {
      _log("尝试查找其他可用的Flutter安装...");
      final foundPath = await findAndFixFlutter();
      if (foundPath.isNotEmpty) {
        flutterPath = foundPath;
        isFlutterValid = true;
        _log("找到并修复了替代Flutter路径: $flutterPath");
      }
    }

    // 步骤5: 创建参数内容 - 包含所有项目配置信息
    // 这些参数会传递给Python脚本用于创建项目
    final params = {
      // 项目类型: app(应用)或module(模块)或plugin(插件)等
      'project_type': projectType,
      // 模板类型: 1(默认)或2(带状态管理)等
      'template_type': templateType,
      // 项目名称: Flutter项目的名称，也将作为目录名
      'project_name': projectName,
      // 包名: Android的包名/iOS的Bundle ID
      'package_name': packageName,
      // 显示名称: 应用在桌面上显示的名称
      'display_name': displayName,
      // 输出目录: 项目将被创建在此目录下
      'output_dir': outputPath,
      // 自动覆盖: 如果目录已存在是否覆盖
      'overwrite': 'y', // 自动覆盖现有目录
      // IDE选择: 项目创建后打开的IDE
      'ide_choice': ideChoice, // 使用用户的IDE选择
      // Flutter路径: Flutter SDK的路径
      'flutter_path': flutterPath, // 添加Flutter路径
      // Flutter有效性标志: 指示路径是否有效
      'flutter_valid': isFlutterValid.toString(), // 添加Flutter路径有效性标志
      // Flutter目录: 用于环境变量
      'flutter_dir': flutterPath.contains('/')
          ? flutterPath.substring(0, flutterPath.lastIndexOf('/'))
          : '', // 添加Flutter目录，用于环境变量
      // 使用绝对路径: 告诉脚本使用绝对路径
      'use_absolute_path': 'true', // 告诉脚本使用绝对路径
      // 允许sudo: 如果需要可以使用sudo
      'allow_sudo': 'true', // 告诉脚本可以在需要时使用sudo
    };

    // 步骤6: 将参数写入文件
    // 每行格式为"键=值"
    await file.writeAsString(
        params.entries.map((e) => "${e.key}=${e.value}").join('\n'));

    return file;
  }

  // Get Flutter path
  Future<String> getFlutterPath(String userSpecifiedPath) async {
    try {
      // Prioritize user-specified Flutter SDK path
      if (userSpecifiedPath.isNotEmpty) {
        _log("Using user-specified Flutter path: $userSpecifiedPath");
        final file = File(userSpecifiedPath);
        if (await file.exists()) {
          // Try to fix permissions immediately if specified manually
          await fixFlutterPermissions(userSpecifiedPath);
          return userSpecifiedPath;
        } else {
          _log("User-specified Flutter path doesn't exist: $userSpecifiedPath");
        }
      }

      // If user didn't specify a path or the specified path is invalid, try to get Flutter path using which command
      final whichResult = await Process.run('which', ['flutter']);
      if (whichResult.exitCode == 0) {
        final flutterPath = whichResult.stdout.toString().trim();
        if (flutterPath.isNotEmpty) {
          _log("Found Flutter path: $flutterPath");

          // Check if file exists
          if (await File(flutterPath).exists()) {
            // Verify if the found path is executable
            if (await isExecutable(flutterPath)) {
              return flutterPath;
            } else {
              _log("Found Flutter path is not executable: $flutterPath");
              // Try to add execution permission
              try {
                await Process.run('chmod', ['+x', flutterPath]);
                _log("Execution permission added");
                if (await isExecutable(flutterPath)) {
                  return flutterPath;
                }
              } catch (e) {
                _log("Failed to add execution permission: $e");
              }
            }
          } else {
            _log("Found Flutter path doesn't exist: $flutterPath");
          }
        } else {
          _log("which command returned an empty path");
        }
      }

      // If which command fails, try some common Flutter installation paths
      final List<String> possiblePaths = [
        '/usr/local/bin/flutter',
        '${Platform.environment['HOME']}/flutter/bin/flutter',
        '${Platform.environment['HOME']}/development/flutter/bin/flutter',
        '${Platform.environment['HOME']}/Documents/flutter/bin/flutter',
        '/opt/homebrew/bin/flutter',
      ];

      for (final path in possiblePaths) {
        if (await File(path).exists()) {
          _log("Found Flutter in common path: $path");

          // Verify if the found path is executable
          if (await isExecutable(path)) {
            return path;
          } else {
            _log("Found Flutter path is not executable: $path");
            // Try to add execution permission
            try {
              await Process.run('chmod', ['+x', path]);
              _log("Execution permission added");
              if (await isExecutable(path)) {
                return path;
              }
            } catch (e) {
              _log("Failed to add execution permission: $e");
            }
          }
        }
      }

      // Try to find flutter in PATH environment variable
      try {
        // Get PATH environment variable correctly
        final result = await Process.run('bash', ['-c', 'echo \$PATH']);
        if (result.exitCode == 0) {
          final pathDirs = result.stdout.toString().trim().split(':');
          for (final dir in pathDirs) {
            if (dir.isEmpty) continue;
            final flutterPath = '$dir/flutter';
            if (await File(flutterPath).exists()) {
              _log("Found Flutter in PATH: $flutterPath");
              if (await isExecutable(flutterPath)) {
                return flutterPath;
              } else {
                // Try to add execution permission
                try {
                  await Process.run('chmod', ['+x', flutterPath]);
                  _log("Execution permission added");
                  if (await isExecutable(flutterPath)) {
                    return flutterPath;
                  }
                } catch (e) {
                  _log("Failed to add execution permission: $e");
                }
              }
            }
          }
        }
      } catch (e) {
        _log("Error finding Flutter in PATH: $e");
      }

      // If all attempts fail, return default flutter command
      onOutputUpdated(
          "\nWarning: Failed to find executable Flutter path, will use system default 'flutter' command\n");
      onOutputUpdated(
          "If project creation fails, please make sure Flutter is properly installed and added to system PATH\n");
      return 'flutter';
    } catch (e) {
      _log("Error getting Flutter path: $e");
      onOutputUpdated("\nWarning: Error getting Flutter path: $e\n");
      onOutputUpdated("Will use system default 'flutter' command\n");
      return 'flutter'; // Return default command
    }
  }

  // 检查文件是否可执行
  Future<bool> isExecutable(String path) async {
    try {
      // 首先检查文件是否存在
      final file = File(path);
      if (!await file.exists()) {
        _log("文件不存在: $path");
        return false;
      }

      // 检查文件是否是目录
      final stat = await file.stat();
      if (stat.type == FileSystemEntityType.directory) {
        _log("路径是一个目录，不是可执行文件: $path");
        return false;
      }

      // 在macOS/Linux上检查文件权限
      if (Platform.isMacOS || Platform.isLinux) {
        try {
          // 使用ls -l命令获取详细权限信息，更可靠
          final lsResult = await Process.run('ls', ['-l', path]);
          if (lsResult.exitCode == 0) {
            final output = lsResult.stdout.toString().trim();
            _log("文件权限信息: $output");

            // 检查输出的第一个字符是否为'-'（常规文件）并且包含'x'（可执行）
            if (output.isNotEmpty && output[0] == '-' && output.contains('x')) {
              _log("文件具有执行权限: $path");
            } else {
              _log("文件不具有执行权限: $path");
              return false;
            }
          }
        } catch (e) {
          _log("检查文件权限时出错: $e");
          // 继续尝试执行，因为ls命令可能不可用
        }

        // 使用test命令检查是否可执行，更可靠的方法
        try {
          final testResult = await Process.run('test', ['-x', path]);
          if (testResult.exitCode != 0) {
            _log("test命令确认文件不可执行: $path");
            return false;
          }
        } catch (e) {
          _log("使用test命令检查可执行状态时出错: $e");
          // 继续尝试执行，因为test命令可能不可用
        }
      }

      // 尝试执行flutter --version来验证命令是否可用
      try {
        final result = await Process.run(path, ['--version'], runInShell: true);
        final isExecutable = result.exitCode == 0;
        _log(isExecutable
            ? "命令可执行: $path"
            : "命令不可执行: $path（退出码: ${result.exitCode}）");
        if (!isExecutable && result.stderr.toString().isNotEmpty) {
          _log("错误输出: ${result.stderr}");
        }
        return isExecutable;
      } catch (e) {
        _log("执行命令时出错: $e");
        return false;
      }
    } catch (e) {
      _log("检查Flutter可执行状态时出错: $e");
      return false;
    }
  }

  // 修复Flutter执行权限
  Future<bool> fixFlutterPermissions(String flutterPath) async {
    try {
      // 检查文件是否存在
      final file = File(flutterPath);
      if (!await file.exists()) {
        onOutputUpdated("\n警告: Flutter路径不存在: $flutterPath\n");
        return false;
      }

      // 获取包含flutter可执行文件的目录
      String flutterDir = flutterPath;
      if (flutterPath.contains('/')) {
        flutterDir = flutterPath.substring(0, flutterPath.lastIndexOf('/'));
      }

      // 使Flutter可执行文件及其所在目录可执行
      try {
        // 为flutter文件添加执行权限
        onOutputUpdated("\n正在为Flutter二进制文件添加执行权限...\n");
        final chmodResult = await Process.run('chmod', ['+x', flutterPath]);
        if (chmodResult.exitCode != 0) {
          onOutputUpdated("\n为Flutter二进制文件添加权限失败: ${chmodResult.stderr}\n");
        }

        // 尝试使用sudo进行更全面的权限修复（如可用）
        onOutputUpdated("\n尝试使用sudo修复权限（可能会提示输入密码）...\n");
        try {
          final sudoResult =
              await Process.run('sudo', ['chmod', '+x', flutterPath]);
          if (sudoResult.exitCode == 0) {
            onOutputUpdated("\n使用sudo成功修复了Flutter权限\n");
          } else {
            onOutputUpdated("\nSudo权限修复失败或不可用: ${sudoResult.stderr}\n");
          }
        } catch (e) {
          onOutputUpdated("\nSudo不可用或失败: $e\n");
        }

        // 修复bin目录中所有文件的权限
        try {
          // ignore: unnecessary_string_interpolations
          final binDir = '$flutterDir';
          if (await Directory(binDir).exists()) {
            onOutputUpdated("\n正在修复Flutter bin目录中所有可执行文件的权限...\n");
            final chmodBinResult =
                await Process.run('chmod', ['-R', '+x', binDir]);
            if (chmodBinResult.exitCode == 0) {
              onOutputUpdated("\n成功修复了Flutter bin目录的权限\n");
            }
          }
        } catch (e) {
          onOutputUpdated("\n修复bin目录权限失败: $e\n");
        }

        // 验证权限是否已修复
        final isExecutableNow = await isExecutable(flutterPath);
        onOutputUpdated(isExecutableNow
            ? "\n权限修复成功！Flutter现在可执行。\n"
            : "\n警告：权限修复后Flutter仍然不可执行。\n");

        return isExecutableNow;
      } catch (e) {
        onOutputUpdated("\n修复Flutter权限时出错: $e\n");
        return false;
      }
    } catch (e) {
      onOutputUpdated("\n修复Flutter权限时发生意外错误: $e\n");
      return false;
    }
  }

  // Run script
  Future<bool> runScript({
    required String projectType,
    required String templateType,
    required String projectName,
    required String packageName,
    required String displayName,
    required String outputPath,
    required String ideChoice,
    required String flutterSdkPath,
  }) async {
    // 步骤1: 更新UI状态，通知开始运行脚本
    onRunningStateChanged(true);
    onOutputUpdated("准备运行脚本...\n");

    try {
      // 步骤2: 检测并选择最合适的Python版本
      // 这一步很重要，因为脚本使用Python编写，需要正确的Python解释器
      String pythonCommand = await _detectPythonCommand();
      onOutputUpdated("\n使用Python命令: $pythonCommand\n");

      // 步骤3: 检查系统Flutter是否可用并修复权限
      // 即使用户指定了自定义Flutter路径，也需要检查系统默认的Flutter
      try {
        final whichResult = await Process.run('which', ['flutter']);
        if (whichResult.exitCode == 0 &&
            whichResult.stdout.toString().trim().isNotEmpty) {
          final systemFlutterPath = whichResult.stdout.toString().trim();
          onOutputUpdated("\n系统Flutter位置: $systemFlutterPath");

          if (!await isExecutable(systemFlutterPath)) {
            onOutputUpdated("\n修复系统Flutter权限...");
            await fixFlutterPermissions(systemFlutterPath);
          }
        }
      } catch (e) {
        onOutputUpdated("\n检查系统Flutter时出错: $e\n");
      }

      // 步骤4: 检查用户指定的Flutter路径并修复权限
      // 如果用户提供了特定的Flutter SDK路径，需要验证并确保它有执行权限
      if (flutterSdkPath.isNotEmpty && flutterSdkPath != "请选择") {
        try {
          onOutputUpdated("\n检查用户指定的Flutter: $flutterSdkPath");
          if (await File(flutterSdkPath).exists()) {
            if (!await isExecutable(flutterSdkPath)) {
              onOutputUpdated("\n修复用户指定的Flutter权限...");
              await fixFlutterPermissions(flutterSdkPath);
            } else {
              onOutputUpdated("\n用户指定的Flutter已具有正确权限");
            }
          }
        } catch (e) {
          onOutputUpdated("\n修复用户Flutter路径时出错: $e\n");
        }
      }

      // 步骤5: 从assets资源提取脚本文件到临时目录
      // 脚本文件打包在应用中，需要先提取到可执行的位置
      onOutputUpdated("提取脚本文件...\n");
      final scriptFile = await extractScriptFromAssets();
      onOutputUpdated("脚本已提取到临时目录: ${scriptFile.path}\n");

      // 步骤6: 创建参数文件，用于向脚本传递配置
      // 使用参数文件而非命令行参数，避免参数过长或特殊字符问题
      onOutputUpdated("创建参数文件...\n");
      final paramsFile = await createParamsFile(
        projectType: projectType,
        templateType: templateType,
        projectName: projectName,
        packageName: packageName,
        displayName: displayName,
        outputPath: outputPath,
        ideChoice: ideChoice,
        flutterSdkPath: flutterSdkPath,
      );
      onOutputUpdated("参数文件已创建: ${paramsFile.path}\n");
      onOutputUpdated("参数内容:\n");
      onOutputUpdated("- 项目类型: $projectType\n");
      onOutputUpdated("- 模板类型: $templateType\n");
      onOutputUpdated("- 项目名称: $projectName\n");
      onOutputUpdated("- 包名: $packageName\n");
      onOutputUpdated("- 显示名称: $displayName\n");
      onOutputUpdated("- 输出目录: $outputPath\n");

      // 步骤7: 获取并显示Flutter路径
      // 无论是用户指定还是自动检测的Flutter路径，都需要显示给用户
      String flutterPath = await getFlutterPath(flutterSdkPath);
      if (flutterPath != 'flutter') {
        onOutputUpdated("- Flutter SDK路径: $flutterPath\n");
      } else {
        onOutputUpdated("- 使用系统Flutter\n");
      }

      // 步骤8: 准备开始运行Python脚本
      onOutputUpdated("\n开始运行Python脚本...\n");

      // 步骤9: 设置环境变量
      // 特别是确保Flutter路径在环境变量中，这对脚本执行很重要
      final Map<String, String> envVars =
          Map<String, String>.from(Platform.environment);

      // 设置PATH和FLUTTER_ROOT环境变量
      const String pathEnvKey = 'PATH';
      String flutterDir = '';

      // 如果使用的是完整Flutter路径(非系统默认的'flutter'命令)
      if (flutterPath != 'flutter' && flutterPath.contains('/')) {
        // 提取Flutter目录路径
        flutterDir = flutterPath.substring(0, flutterPath.lastIndexOf('/'));

        // 检查是否为bin目录，若是则使用其父目录作为FLUTTER_ROOT
        if (flutterDir.endsWith('/bin')) {
          final flutterRoot =
              flutterDir.substring(0, flutterDir.length - 4); // 移除'/bin'
          envVars['FLUTTER_ROOT'] = flutterRoot;
          onOutputUpdated("设置FLUTTER_ROOT环境变量: $flutterRoot\n");
        } else {
          envVars['FLUTTER_ROOT'] = flutterDir;
          onOutputUpdated("设置FLUTTER_ROOT环境变量: $flutterDir\n");
        }

        // 将Flutter目录添加到PATH环境变量(如果尚未包含)
        if (envVars.containsKey(pathEnvKey)) {
          if (!envVars[pathEnvKey]!.contains(flutterDir)) {
            envVars[pathEnvKey] = "$flutterDir:${envVars[pathEnvKey]}";
            onOutputUpdated("将Flutter目录添加到PATH: $flutterDir\n");
          }
        } else {
          envVars[pathEnvKey] = flutterDir;
        }
      }

      // 步骤10: 确保脚本有执行权限
      // 这是在macOS/Linux系统上运行脚本的必要条件
      try {
        await Process.run('chmod', ['+x', scriptFile.path]);
      } catch (e) {
        onOutputUpdated("警告: 为脚本添加执行权限失败: $e\n");
      }

      // 步骤11: 尝试运行脚本 - 主要执行方法
      // 使用Process.start启动一个进程，可以实时获取输出
      try {
        _process = await Process.start(
          pythonCommand,
          [
            scriptFile.path,
            '--params-file',
            paramsFile.path,
          ],
          environment: envVars,
          workingDirectory: Directory.systemTemp.path,
        );

        onOutputUpdated("脚本进程已启动，进程ID: ${_process!.pid}\n");

        // 步骤12: 监听标准输出流
        // 将脚本的输出实时传递给UI
        _process!.stdout
            .transform(const SystemEncoding().decoder)
            .listen((data) {
          onOutputUpdated(data);
          _log('标准输出');
          _log(data);
        });

        // 步骤13: 监听错误输出流
        // 捕获并显示脚本执行过程中的错误
        _process!.stderr
            .transform(const SystemEncoding().decoder)
            .listen((data) {
          onOutputUpdated("错误: $data");
          _log('错误输出');
          _log(data);
        });

        // 步骤14: 等待进程完成并获取退出码
        final exitCode = await _process!.exitCode;

        // 步骤15: 处理非零退出码 - 尝试备用执行方法
        if (exitCode != 0) {
          onOutputUpdated("\n脚本以退出码 $exitCode 失败\n");
          onOutputUpdated("尝试备用执行方法...\n");

          // 使用shell直接执行脚本的方式再试一次
          try {
            final directResult = await Process.run(
                'sh',
                [
                  '-c',
                  "$pythonCommand ${scriptFile.path} --params-file ${paramsFile.path}"
                ],
                environment: envVars);
            onOutputUpdated("\n备用执行输出:\n${directResult.stdout}\n");
            if (directResult.stderr.toString().isNotEmpty) {
              onOutputUpdated("错误: ${directResult.stderr}\n");
            }
          } catch (e) {
            onOutputUpdated("备用执行方法也失败: $e\n");
          }
        } else {
          onOutputUpdated("\n脚本执行完成，退出码: $exitCode");
        }
      } catch (e) {
        // 步骤16: 处理主执行方法失败的情况
        onOutputUpdated("\n启动Python脚本时出错: $e\n");
        onOutputUpdated("尝试备用执行方法...\n");

        // 使用shell执行作为最后的备用方案
        try {
          final shellResult = await Process.run(
              'sh',
              [
                '-c',
                "$pythonCommand ${scriptFile.path} --params-file ${paramsFile.path}"
              ],
              environment: envVars);
          onOutputUpdated("\nShell执行输出:\n${shellResult.stdout}\n");
          if (shellResult.stderr.toString().isNotEmpty) {
            onOutputUpdated("错误: ${shellResult.stderr}\n");
          }
        } catch (e) {
          onOutputUpdated("Shell执行也失败: $e\n");
        }
      }

      // 步骤17: 清理 - 删除参数文件
      // 参数文件可能包含敏感信息，使用后应删除
      try {
        await paramsFile.delete();
      } catch (e) {
        onOutputUpdated("\n警告: 删除参数文件失败: $e\n");
      }

      // 步骤18: 验证结果 - 检查项目目录是否已创建
      // 通过检查输出目录中是否存在项目目录来验证脚本执行成功
      final projectDir = Directory('$outputPath/$projectName');
      final projectExists = await projectDir.exists();

      if (projectExists) {
        onOutputUpdated("\n项目目录验证成功: $outputPath/$projectName 已创建");
      } else {
        onOutputUpdated("\n警告: 未找到项目目录 $outputPath/$projectName");

        // 步骤19: 尝试在其他可能的位置查找项目目录
        // 有时项目可能创建在其他位置，如当前目录或小写名称
        final otherPossibleDirs = [
          Directory('$outputPath/${projectName.toLowerCase()}'),
          Directory(projectName),
          Directory('${Directory.current.path}/$projectName'),
        ];

        bool alternateFound = false;
        for (final dir in otherPossibleDirs) {
          if (await dir.exists()) {
            onOutputUpdated("\n在其他位置找到项目: ${dir.path}");
            alternateFound = true;
            break;
          }
        }

        if (!alternateFound) {
          onOutputUpdated("\n在任何预期位置均未找到项目目录。");
        }
      }

      // 步骤20: 完成 - 更新UI状态
      onRunningStateChanged(false);
      return projectExists;
    } catch (e) {
      // 步骤21: 异常处理 - 捕获并报告任何未处理的错误
      onOutputUpdated("\n执行脚本时发生错误: $e");
      onRunningStateChanged(false);
      return false;
    }
  }

  // 检测可用的Python命令
  Future<String> _detectPythonCommand() async {
    onOutputUpdated("正在检测Python版本...\n");

    // 首先尝试python3（macOS/Linux上常见）
    try {
      final python3Result = await Process.run('python3', ['--version']);
      if (python3Result.exitCode == 0) {
        onOutputUpdated("找到Python 3: ${python3Result.stdout}");
        return 'python3';
      }
    } catch (e) {
      onOutputUpdated("Python3不可用: $e\n");
    }

    // 尝试python（在某些系统上可能是Python 3）
    try {
      final pythonResult = await Process.run('python', ['--version']);
      if (pythonResult.exitCode == 0) {
        final version = pythonResult.stdout.toString();
        onOutputUpdated("找到Python: $version");
        // 检查是否为Python 3
        if (version.contains('Python 3')) {
          return 'python';
        } else {
          onOutputUpdated("警告: 找到Python但不是版本3。脚本可能无法正常工作。\n");
          return 'python'; // 仍然使用，作为最后的选择
        }
      }
    } catch (e) {
      onOutputUpdated("Python不可用: $e\n");
    }

    // 在常见位置查找Python3
    final commonPythonPaths = [
      '/usr/bin/python3',
      '/usr/local/bin/python3',
      '/opt/homebrew/bin/python3',
      '${Platform.environment['HOME']}/.pyenv/shims/python3',
    ];

    for (final path in commonPythonPaths) {
      if (await File(path).exists()) {
        try {
          final versionResult = await Process.run(path, ['--version']);
          if (versionResult.exitCode == 0) {
            onOutputUpdated("在 $path 找到Python: ${versionResult.stdout}");
            return path;
          }
        } catch (e) {
          // 继续检查其他路径
        }
      }
    }

    // 默认使用python3并希望能正常工作
    onOutputUpdated("警告: 无法验证Python安装。使用'python3'命令。\n");
    return 'python3';
  }

  // 停止脚本
  void stopScript() {
    if (_process != null) {
      _process!.kill();
      onOutputUpdated("\n脚本已手动停止");
      onRunningStateChanged(false);
    }
  }

  // 清理资源
  void dispose() {
    // 确保进程已终止
    _process?.kill();
  }

  // 查找并修复Flutter安装
  Future<String> findAndFixFlutter() async {
    try {
      // 常见的Flutter安装路径
      final List<String> possiblePaths = [
        '${Platform.environment['HOME']}/flutter/bin/flutter',
        '${Platform.environment['HOME']}/development/flutter/bin/flutter',
        '${Platform.environment['HOME']}/Documents/flutter/bin/flutter',
        '/usr/local/bin/flutter',
        '/opt/flutter/bin/flutter',
        '/opt/homebrew/bin/flutter',
      ];

      // 检查每个路径
      for (final path in possiblePaths) {
        if (await File(path).exists()) {
          onOutputUpdated("\n在以下位置找到Flutter: $path\n");

          // 尝试修复权限
          if (await fixFlutterPermissions(path)) {
            return path;
          }
        }
      }

      return '';
    } catch (e) {
      onOutputUpdated("\n查找并修复Flutter时出错: $e\n");
      return '';
    }
  }
}
